\subsection{Bausteine}
\label{sec:Bausteine}
Im folgenden werden die einzelnen Bausteine, aus denen moderne Verschl\"us\-selung\-salgorithmen zusammengesetzt werden, genauer beschrieben. Die meisten dieser Bausteine befinden sich bereits seit Jahren in Verwendung und sind sehr gut auf ihre Eignung in Kryptosystemen gepr\"uft. Bei der Entwicklung neuer Verschl\"usselungsverfahren werden selten neue Bausteine entwickelt, sondern die hier angegebenen neu kombiert.\\
Die Beschreibung der einzelnen Bausteine ist aufgeteilt in strukturelle Bausteine, Operationen auf Matrizen und Operationen auf Ganzzahlen.\\
Im folgenden beziehen sich alle Aussagen auf Blockcipher mit $\KM=\KC=\{0,1\}^{n}$ und $\KK=\{0,1\}^{m}$ mit $m,n\in \mathbb{N}, n>1,m>1$. Zus\"atzlich verwenden wir $\Sigma$ f\"ur eine endliche Menge auch Alphabet genannt.

\subsubsection{Interpretation der Eingaben}
\label{subsubsec:eingabe}
Bei modernen Verschl\"usselungsalgorithmen wird die Eingabe auf unterschiedliche Art interpretiert. \\
Wie oben gefordert sind die Eingaben der Algorithmen als Bitvektoren der L\"ange $n$ bzw. $m$ gegeben.\\
Wir werden die in der Informatik \"ublichen Bezeichnungen f\"ur 4-- (Nibble), 8-- (Byte), 16-- (Word) bzw. 32-- (Dword) Bitvektoren verwenden.\\
Neben dieser Darstellung werden sie allerdings auch als Ganzzahlen oder Matrizen (bzw. Matrizen von Ganzzahlen) aufgefasst. F\"ur alle diese F\"alle existieren folgende Bijektionen zur Umwandlung: 
\begin{equation*}
\begin{array}{ll}
BV2Integer:\left\{\begin{array}{ll}\{0,1\}^{n}&\rightarrow\mathbb{N}\\
(x_{0},x_{1},\ldots,x_{n-1})&\mapsto \sum_{i=0}^{n-1} x_{i}\cdot2^{n-(i+1)}\end{array}\right.
\end{array}
\end{equation*}
\begin{equation*}
\begin{array}{ll}
V2Matrix:\left\{\begin{array}{ll}\Sigma^{n}&\rightarrow\Sigma^{k}\times\Sigma^{l}\\
(x_{0},x_{1},\ldots,x_{n-1})&\mapsto \left(\begin{array}{llll} x_{0} & x_{1} & \ldots &x_{k-1}\\
x_{k} & x_{k+1} & \ldots &x_{2\cdot k-1}\\
\vdots & \vdots & \vdots & \vdots\\
x_{(l-1)\cdot k} & x_{(l-1)\cdot k+1} &\ldots & x_{l\cdot k -1}\end{array}\right)
 \end{array}\right.\\
mit\ k\cdot l=n
\end{array}
\end{equation*}

% \begin{equation*}
% \begin{array}{ll}
% BV2Matrix:\left\{\begin{array}{ll}\{0,1\}^{n}&\rightarrow\{0,1\}\times\{0,1\}\\
% (x_{0},x_{1},\ldots,x_{n})&\mapsto x_{0}\cdot 2^{n-1} + x_{1}\cdot 2^{n-2}+\ldots + x_{n} \end{array}\right.
% \end{array}
% \end{equation*}

\subsubsection{Strukturelle Bausteine}
\label{subsubsec:strukturell}
\paragraph{Keyschedule}
\begin{description}
%\item[Abk\"urzungen/Symbole:] {}
\item[Definition:] {Der Keyschedule ist definiert als Abbildung
\begin{equation*}
\begin{array}{ll}
Key:&\begin{array}{ll}\{0,1\}^{n}&\rightarrow(\{0,1\}^{l})^{m}\end{array}
\end{array}
\end{equation*}}
\item[Beschreibung:] {Der Keyschedule (auch Keyexpansion oder Schl\"usselerzeugung) ist eine Funktion, mit der aus dem gegebenen Schl\"ussel neue (Runden)\-Schl\"ussel gewonnen werden. Dieser Algorithmus ist meist \"ahnlich komplex wie der Verschl\"usselungsalgorithmus selbst.}
\item[Herkunft:]{Wie die weiter unten genannten Feistel\-netzwerke entstanden Key\-schedules im Rahmen des Lucifer-Projektes bei IBM zu Beginn der 1970er Jahre.}
\item[Verwendung:]{Alle betrachteten Algorithmen verwenden Keyschedules zur Erzeugung von Teilschl\"usseln, die dann im Ablauf des Algorithmus mittels einer der weiter unten genannten Funktionen mit dem Klartext verkn\"upft werden.}
%\item[Beispiele:] {}
\end{description}

\paragraph{Feistelnetzwerk}
\begin{description}
%\item[Abk\"urzungen/Symbole:] {}
\item[Definition:] {Ein Feistelnetzwerk ist definiert als:
\begin{equation*}
\begin{array}{ll}
Feistel:&\left\{
\begin{array}{l}\{0,1\}^{2n}\times KernF \times \mathbb{N}\times (\{0,1\}^{n} )^{m}\rightarrow\{0,1\}^{2n}\\
(x,f,0,K)\mapsto x\\
(x,f,n,K)\mapsto \left\{\begin{array}{l}Feistel (right(x) \cdot\\ \hspace{2ex} (left (x)\oplus f(right(x), \pi_n (K))),\\\hspace{4ex} f, n - 1, K),\ f\ddot ur\:n>0\end{array}\right.\\
\end{array}\right.
\end{array}
\begin{array}{ll}
%Feistel:&\{0,1\}^{2n} \times KernF \times \mathbb{N} \times \{\{0,1\}^{n}\}^{m} \rightarrow\{0,1\}^{n}\\
%&(x,F,0,K)\mapsto x\\
%&(x,F,n,K)\mapsto \left\{\begin{array}{l}Feistel (right(x) \cdot\\ \hspace{2ex} left (x)\oplus F(right(x), nth %(K,n)),\\\hspace{4ex} F, n - 1, K)\end{array}\right.\\
\end{array}
\end{equation*}
wobei
\begin{equation*}
KernF\subseteq\{f | f: \{0,1\}^{n}\times \{0,1\}^{n}\rightarrow\{0,1\}^{n}\}
\end{equation*}
\begin{equation*}
\begin{array}{ll}
left:& \left\{
        \begin{array}{ll} 
            \{0,1\}^{2n}&\rightarrow\{0,1\}^{n}\\
            (x_{0}, x_{1}, x_{2}, \ldots x_{2n-1})&\mapsto (x_0,x_1,\ldots,x_{n-1})\\
        \end{array}
        \right.\\[2ex]
right:& \left\{
        \begin{array}{ll} 
            \{0,1\}^{2n}&\rightarrow\{0,1\}^{n}\\
            (x_{0}, x_{1}, x_{2}, \ldots x_{2n-1})&\mapsto (x_n, x_{n+1}, \ldots, x_{2n-1})\\
        \end{array}
        \right.\\[2ex]
\pi_{i}:&   \left\{
        \begin{array}{ll} \Sigma^{m}&\rightarrow \Sigma\\
            (x_0,x_1,\ldots,x_{m-1})&\mapsto x_{i}
        \end{array}\right.\\
\end{array}
\end{equation*}
\begin{equation*}
\begin{array}{ll}
\cdot:& \left\{
        \begin{array}{ll} \{0,1\}^{n}\times\{0,1\}^{n}&\rightarrow\{0,1\}^{2n}\\
            \left(\left(\begin{array}{l}x_{0}\\ x_{1}\\ x_{2}\\ \vdots\\ x_{n-1}\end{array}\right),
\left(\begin{array}{l}y_{0}\\ y_{1}\\ y_{2}\\ \vdots\\y_{n-1}\end{array}\right)\right)&\mapsto\left(\begin{array}{l}x_{0}\\ x_{1}\\ x_{2}\\ \vdots\\ x_{n-1}\\y_{0}\\y_{1}\\\vdots\\y_{n-1}\end{array}\right)\\
            \end{array}
        \right.\\
\end{array}
\end{equation*}}
\item[Beschreibung:] {Ein Feistelnetzwerk wird $n$ mal durchlaufen, jeder dieser Durch\-mal\"aufe wird als Runde bezeichnet. In der $i$-ten Runde wird der Eingabeblock $I_{i}=L_{i}R_{i}$ in $L_i$ und $R_i$ aufgeteilt. Der Ausgabeblock $O_{i}=L_{i+1}R_{i+1}$ wird berechnet als.
\begin{eqnarray*}
L_{i+1} & = & R_{i}\\
R_{i+1} & = & L_{i}\oplus f(R_{i}, K_i)\\
\end{eqnarray*}
wobei $L_0R_0$ der vorverarbeitete Klartextblock, $f$ die Kernfunktion des Feistelnetzwerkes, $K_i$ der $i-$te Rundenschl\"ussel ist und $\oplus$ die $xor$-Funktion (siehe Abschnitt \ref{subsubsec:vektorundmatrix}). Es existieren zahlreiche Variationen dieses Basisschemas, beispielsweise kann der Ein\-gabeblock in zwei unterschiedlich gro\ss{}e oder in vier Teilbl\"ocke aufgespalten werden oder es kann Addition modulo $n$ bei der Berechnung von $R_{i+1}$ verwendet werden.
}
\item[Herkunft:]{Feistelnetzwerke wurden bei IBM Anfang der 1970er Jahren im Rahmen des Lucifer-Projekt von Horst Feistel entwickelt.}
\item[Verwendung:]{Wie die unten angegebene Tabelle (siehe Abschnitt \ref{algorithmtables}) zeigt, verwenden fast alle der hier betrachteten Algorithmen Feistelnetzwerke als Kern der Verschl\"usselung, wobei auch die oben genannten Variationen zum Einsatz kommen.}
%\item[Beispiele:] {}
\end{description}

\subsubsection{Substitutions-Box}
\label{subsubsec:sbox}
\begin{description}
\item[Abk\"urzungen/Symbole:] {S-Box}
\item[Definition:] {
\begin{eqnarray*}
S\!\!-\!\!Box:&\{0,1\}^{n}\rightarrow\{0,1\}^{m},injektiv
\end{eqnarray*}}
\item[Beschreibung:] {Bei der Anwendung einer S-Box wird ein gegebener Eingabeblock durch einen Ausgabeblock ersetzt. Es wird gefordert, dass die S-Box eine nichtlineare Transformation von Eingabe- zu Ausgabebl\"ocken ist. In den meisten F\"allen sind S-Boxen feste Look-up-Tabellen, dar\"uber hinaus existieren allerdings auch schl\"usselabh\"angige S-Boxen, deren Werte durch initiale Werte und darauffolgende Transformation durch den Schl\"ussel berechent werden. Weiter ist es m\"oglich, Blockcipher selbst als S-Boxen anderer Blockcipher zu verwenden. }
\item[Herkunft:]{Wie Feistelnetzwerke entstanden auch S-Boxen Anfang der 1970er Jahre bei IBM im Rahmen des Lucifer-Projekts.}
\item[Verwendung:]{Die meisten der hier betrachteten Algorithmen verwenden S-Boxen (siehe Anhang \ref{algorithmtables}), mit Ausnahme von TWOFISH \cite{Twofish} werden Look-up-Tabellen mit festen Werten verwendet. TWOFISH verwendet schl\"us\-sel\-ab\-h\"ang\-ige S-Boxen.}
%\item[Beispiele:] {}
\end{description}

\subsubsection{Operationen auf Vektoren und Matrizen}
\label{subsubsec:vektorundmatrix}
\paragraph{Permutations-Box}
\begin{description}
\item[Abk\"urzungen/Symbole:] {P-Box}
\item[Definition:] {
\begin{eqnarray*}
P\!\!-\!\!Box:&\left\{\begin{array}{ll}\{0,1\}^{n}&\rightarrow\{0,1\}^{n}\\
(x_{0}, x_{1}, \ldots ,x_{n-1})&\mapsto (x_{\pi(0)}, x_{\pi(1)}, \ldots, x_{\pi(n-1)})\\
\end{array}\right.
\end{eqnarray*}}
wobei
\begin{equation*}
\pi:\{0,1,\ldots, n-1\}\rightarrow\{0,1,\ldots , n-1\},\ bijektiv
\end{equation*}
\item[Beschreibung:] {Eine P-Box ist eine fest vorgegebene Permutation der Positionen der Eingabebits. }
\item[Herkunft:]{Wie S-Boxen und Feistelnetzwerke sind auch P-Boxen im Rahmen des Lucifer-Projekts bei IBM Anfang der 1970er Jahren entstanden.}
\item[Verwendung:]{In aktuellen Algorithmen werden P-Boxen nur noch selten verwendet (siehe Anhang \ref{algorithmtables}) und zumeist durch eine oder mehrere der folgenden Operationen ersetzt.}
%\item[Beispiele:] {}
\end{description}

\paragraph{Maximum-Distance-Separable-Code}
\begin{description}
\item[Abk\"urzungen/Symbole:] {MDS}
\item[Definition:] {Zur Definition eines MDS-Codes ben\"otigen wir zun\"achst einige weitere Begriffe. Wir halten uns dabei an \cite{Codierungstheorie}.
\begin{description}
\item[Code:] {$C$ eine Teilmenge von $\mathbb{F}_{q}^{n}$ hei�t Code.}
\item[L\"ange eines Codes:] {F\"ur $C\subseteq F_{q}^{n}$ ist $n$ die L\"ange des Codes.}
\item[Anzahl der Worte:] {$M=|C|$ ist die Anzahl der Codeworte in $C$.}
\item[Hammingabstand:] {$d_{h}((x_{0},x_{1}, \ldots, x_{n-1}),(y_{0}, y_{1}, \ldots, y_{n-1})) := |\{i | x_{i}-y_{i} \not = 0\}|$}
\item[Minimalabstand:]$d(C):=Min\{d_{h}(x,y)|x,y\in C, x\not = y\}$ 
\end{description}
F\"ur jeden Code $C$ gilt: $M\leq q^{n-d(C)+1}$. Wird $M=q^{n-d(C)+1}$ erreicht, wird $C$ als MDS-Code bezeichnet.\\
Im allgemeinen wird f\"ur in Verschl\"usselungsalgorithmen eingesetzten MDS-Codes verlangt, dass diese einen Vektorraum \"uber $\mathbb{F}_{q}^{n}$ bilden.}
\item[Beschreibung:] {MDS-Codes sind ein wie oben definierter Speziallfall der Kanalkodierung. In den von uns betrachteten Algorithmen werden Codes verwendet, deren Codierungsregelen sich als Matrix-Multiplikation darstellen lassen. Die innerhalb des Codes zur Anwendung kommende Matrix bezeichnen wir als MDS-Matrix.}
\item[Herkunft:]{MDS-Matrizen wurden zuerst im SHARK-Algorithmus verwendet. \cite{Rijndael}}
\item[Verwendung:]{SHARK \cite{Rijndael}, SQUARE \cite{SQUARE} und Rijndael \cite{Rijndael} verwenden MDS-Matrizen als wesentlichen Teil der Kernfunktion, hierbei wird auf dem gesamten Datenblock gearbeitet. TWOFISH verwendet eine MDS-Matrix als Teil seiner Kernfunktion.}
\item[Beispiele:] {Reed-Solomon-Codes sowie die MixColumns-Operation in AES und die Teile der Kernfunktion von TWOFISH sind Beispiele f\"ur Maximum Distance Separable-Codes. }
\end{description}

\paragraph{Rotation}
\begin{description}
\item[Abk\"urzungen/Symbole:] {$<\!\!<\!\!<\!n$, $<\!\!<\!\!<_{n}$, $rol(\ldots,n)$, $>\!\!>\!\!>\!n$, $>\!\!>\!\!>_{n}$, $ror(\ldots,n)$}
\item[Definition:] {Die Links-Rotation ist definiert als:
\begin{equation*}
\begin{array}{ll}
<\!\!<\!\!<_{1}:&\left\{\begin{array}{ll}\{0,1\}^{n}&\rightarrow\{0,1\}^{n}\\
(x_{0}, x_{1}, x_{2}, \ldots x_{n-1}) &\mapsto (x_{1},x_{2},\ldots x_{n-1}, x_{0})\end{array}\right.\\
\end{array}
\end{equation*}
ensprechend f\"ur die Rechts-Rotation:
\begin{equation*}
\begin{array}{ll}
>\!\!>\!\!>_{1}:&\left\{\begin{array}{ll}\{0,1\}^{n}&\rightarrow\{0,1\}^{n}\\
(x_{0}, x_{1}, x_{2}, \ldots x_{n-1})&\mapsto (x_{n-1},x_{0},x_{1},\ldots x_{n-2})\end{array}\right.\\
\end{array}
\end{equation*}

mit $<\!\!<\!\!<_{n}\::=\:(<\!\!<\!\!<_{1})^{n}$ und $>\!\!>\!\!>_{n}\::=(\:>\!\!>\!\!>_{1})^{n}$
}
\item[Beschreibung:] {Mittels Rotation werden die Bits eines spezifischen numerischen Datentyps (meist Byte oder Dword) um $n$ nach links oder rechts rotiert. Hierbei unterscheidet man zwischen fester Rotation (fixed Rotation), bei der die Daten immer mit einem festen Wert f\"ur $n$ rotiert werden und datenabh\"angiger Rotation (datadependent Rotation), bei der der Wert f\"ur $n$ aus Daten berechnet wird, die beim Durchlauf durch den Algorithmus entstehen.}
\item[Herkunft:]{Feste Rotation\\  Datenabh\"angige Rotation wurde von IBM in den sp\"aten 1970ern eingef\"uhrt, st\"arkere Beachtung finden sie seit Ron Rivest RC5 \cite{RC5} Algorithmus.}
\item[Verwendung:]{Alle AES-Kandidaten der zweiten Runde mit Ausnahme von Rijndael benutzen feste Rotation mit unterschiedlichen Werten f\"ur $n$ (TWOFISH: $n=1$, MARS: $n=5,8, 13$, Serpent: $n=7, 13 22$). MARS \cite{MARS} benutzen dar\"uber hinaus datenabh\"angige Rotation. RC6 verwendet nur datenabh\"angige Rotation.}
\item[Beispiele:] {
Sei $n=8$\\
$00101000<\!\!<\!\!<_{4}=00101000(<\!\!<\!\!<_{1})^{4}\:=01010000(<\!\!<\!\!<_{1})^{3}\:=\ldots = 01000001$\\
$00101000>\!\!>\!\!>_{2}=00101000(>\!\!>\!\!>_{1})^{2}\:=00010100(>\!\!>\!\!>_{1})^{1}\:=00001010$\\
}
\end{description}

\paragraph{(Arithmetischer) Shift}
\begin{description}
\item[Abk\"urzungen/Symbole:] {$<\!\!<\!n$, $<\!\!<_{n}$, $>\!\!>n$, $>\!\!>_{n}$}
\item[Definition:] {Die Links-Shift-Operation ist definiert als:
\begin{equation*}
\begin{array}{ll}
<\!\!<_{1}:&\left\{\begin{array}{ll}\{0,1\}^{n}&\rightarrow\{0,1\}^{n}\\
(x_{0}, x_{1}, x_{2}, \ldots x_{n-1}) &\mapsto (x_{1},x_{2},\ldots x_{n-1}, 0)\end{array}\right.\\
\end{array}
\end{equation*}
entsprechend f\"ur Rechts-Shift:
\begin{equation*}
\begin{array}{ll}
>\!\!>_{1}:&\left\{\begin{array}{ll}\{0,1\}^{n}&\rightarrow\{0,1\}^{n}\\
(x_{0}, x_{1}, x_{2}, \ldots x_{n-1})&\mapsto (0,x_{0},x_{1},\ldots x_{n-2})\end{array}\right.\\
\end{array}
\end{equation*}
mit $<\!\!<_{n}\::=\:(<\!\!<_{1})^{n}$ und $>\!\!>_{n}\::=\:(>\!\!>_{1})^{n}$.}
\item[Beschreibung:] {Die arithmetische Shift-Operation ist equivalent zu einer Multiplikation mit $2^{n}$, bei der die \"Ubertragsbits verworfen werden.}
%\item[Herkunft:]{}
\item[Verwendung:]{Die Shift-Operation wird aufgrund des oben beschriebenen Datenverlustes nur selten in der Verschl\"usselungsfunktion selbst eingesetzt, sondern zumeist im Rahmen der Keyexpansion verwendet. Eine Ausnahme bildet SERPENT \cite{Serpent}, welcher Shifts verwendet, um nur Teile von Klartextbl\"ocken mit $xor$ zu verkn\"upfen.}
\item[Beispiele:] {Sei $n=8$\\
$00101000>\!\!>_{2}=00101000(>\!\!>_{1})^{2}\:=00010100(>\!\!>_{1})^{1}\:=00001010$\\
$00101000<\!\!<_{4}=00101000(<\!\!<_{1})^{4}\:=01010000(<\!\!<_{1})^{3}\:=\ldots = 01000000$\\
}
\end{description}

\paragraph{Exklusives Oder}
\begin{description}
\item[Abk\"urzungen/Symbole:] {$xor$, $exor$, $\oplus$}
\item[Definition:] {$xor$ ist definiert als:
\begin{equation*}
\begin{array}{ll}
%xor:&\left\{\begin{array}{ll}\{0,1\}\times\{0,1\}&\rightarrow\{0,1\}\\
\begin{array}{c|cc}xor&0&1\\\hline0&0&1\\1&1&0\\\end{array}
% (0,0)&\mapsto 0\\
% (1,0)&\mapsto 1\\
% (0,1)&\mapsto 1\\
% (1,1)&\mapsto 0\\
%\end{array}\right.
\end{array}
\end{equation*}
Die $xor$-Operation kann komponentenweise auf $n$-Bitvektoren ausgeweitet werden.
\begin{equation*}
\begin{array}{ll}
xor_{n}:&\left\{\begin{array}{ll} \{0,1\}^{n}\times\{0,1\}^{n}&\rightarrow\{0,1\}^{n}\\

\left(\left(\begin{array}{l}x_{0}\\ x_{1}\\ x_{2}\\ \vdots\\ x_{n-1}\end{array}\right),
\left(\begin{array}{l}y_{0}\\ y_{1}\\ y_{2}\\ \vdots\\y_{n-1}\end{array}\right)\right)&\mapsto \left(\begin{array}{l}xor(x_{0},y_{0})\\xor(x_{1},y_{1})\\xor(x_{2},y_{2})\\\vdots\\ xor(x_{n-1},y_{n-1})\end{array}\right)
\end{array}\right.
\end{array}\\
\end{equation*}}
\item[Beschreibung:] {Die logische Exklusiv-Oder-Operation}
%\item[Herkunft:]{}
\item[Verwendung:]{Die $xor$-Operation wird in allen betrachteten Algorithmen verwendet, unter anderem, um Klartextbl\"ocke und Schl\"ussel miteinander zu verkn\"upfen.}
\item[Beispiele:] {
$xor_{4}(1111,1010)=0101$\\
$xor_7(1000000,00010000)=10010000,$\\
}
\end{description}

\subsubsection{Operationen auf Ganzzahlen}
\label{subsubsec:ganzzahlen}

\paragraph{Pseudo-Hadamard-Transformation}
\begin{description}
\item[Abk\"urzungen/Symbole:] {PHT}
\item[Definition:] {Pseudo-Hadamard-Trans\-for\-ma\-tionen sind definiert als:
\begin{equation*}
\begin{array}{ll}
PHT_{n}:&\left\{\begin{array}{ll}\mathbb{Z}_{n}\times\mathbb{Z}_{n}&\rightarrow\mathbb{Z}_{n}\times\mathbb{Z}_{n}\\
(a,b)&\mapsto (a + b\bmod 2^{n}, a + 2 \cdot b\bmod 2^{n})\end{array}\right.\\
\end{array}
\end{equation*}
}
\item[Beschreibung:] {Pseudo-Hadamard-Trans\-for\-ma\-tionen sind von Hadamard-Trans\-for\-ma\-tionen, einer allgemeinen Klasse von Fourier\-trans\-for\-ma\-tionen ab\-ge\-leitete Operation, bei denen zwei Eingabewerte wie oben beschrieben verkn\"upft werden.}
\item[Herkunft:]{Pseudo-Hadamard-Trans\-for\-ma\-tionen wurden zuerst im SAFER Algorithmus verwendet.}
\item[Verwendung:]{SAFER verwendet drei hintereinandergeschaltete Pseudo-Ha\-da\-mard-Trans\-for\-ma\-tionen pro Runde. TWOFISH verwendet eine Pseudo-Ha\-da\-mard-Transformation als Teil der Kernfunktion seines Feistelnetzwerkes.}
\item[Beispiele:] {Sei $n=8$
\begin{equation*}
\begin{array}{lll}PHT_{8}(255, 10) &=& (255 + 10 \bmod 2^{8}, 255+2\cdot 10\bmod 256)\\
&=&  (265 \bmod 256, 275 \bmod 256)\\
&=& (9, 19)\end{array}
\end{equation*}
}
\end{description}


\paragraph{Exponentiation/Logarithmus modulo $n$}
\begin{description}
%\item[Abk\"urzungen/Symbole:] {}
\item[Definition:] {Exponentiation ist definiert als
\begin{equation*}
\begin{array}{ll}
exp:&\left\{\begin{array}{ll}\mathbb{Z}_{n}\times\mathbb{Z}_{n}&\rightarrow \mathbb{Z}_{n}\\
(x,y) &\mapsto x^{y}\bmod n\end{array}\right.\\
\end{array}
\end{equation*}
der diskrete Logarithmus ist die Umkehrfunktion zu exp (sofern sie existiert)
\begin{equation*}
\begin{array}{ll}
log:&\left\{\begin{array}{ll}\mathbb{Z}_{n}\times\mathbb{Z}_{n}&\rightarrow \mathbb{Z}_{n}\\
(x,y) &\mapsto z\ mit\ y=x^{z} \bmod n\end{array}\right.\\
\end{array}
\end{equation*}}
$log(x,y)$ ist in $\mathbb{Z}_{n}$ nur definiert wenn $y\in\mathbb{Z}_{n}^{\times}$.
\item[Beschreibung:] {Die Exponentiation bzw. der Logarithmus modulo $n$}
\item[Herkunft:]{Exponentiation und Logarithmus modulo $n$ wurden f\"ur Blockcipher vom SAFER Algorithmus eingef\"uhrt.}
\item[Verwendung:]{SAFER ist der einzige Algorithmus, der diese Operation verwendet. Hierbei werden $x=45$ und $n=257$ vorgegeben. Allerdings wird meist zur Erh\"ohung der Geschwindigkeit eine Look-up-Tabelle anstatt der Berechnung verwendet.}
\item[Beispiele:] {Sei $n=257$\\
$exp (45, 4) = 45^{4} \bmod 257 = 410065 \bmod 257 = 190 $\\
$log (45, 190) = log_{45}190\bmod 257=4$}
\end{description}

\paragraph{Multiplikation modulo $n$}
\begin{description}
\item[Abk\"urzungen/Symbole:] {$\circledast$, $\cdot\bmod n$, $\cdot_{n}$, $\odot$, $\boxtimes$}
\item[Definition:] {Die Multiplikation modulo $n$ ist definiert als:
\begin{equation*}
\begin{array}{ll}
\circledast:&\left\{\begin{array}{ll}\mathbb{Z}_{n}\times\mathbb{Z}_{n}&\rightarrow \mathbb{Z}_{n}\\
(x,y) &\mapsto x\cdot y\bmod n\end{array}\right.\\
\end{array}
\end{equation*}}
\item[Beschreibung:] {Die Multiplikation modulo $n$}
\item[Herkunft:]{Multiplikation modulo $n$ wurde bereits in der affin-linearen Chiffre verwendet, in der modernen Kryptographie wurde sie zuerst im IDEA Algorithmus eingesetzt.}
\item[Verwendung:]{Von den betracheten Algorithmen verwendet IDEA, MARS und RC6 Multiplikation modulo $n$. Hierbei ist zu beachten, dass die Multiplikation von IDEA leicht modifiziert ist.}
\item[Beispiele:] {
Sei $n = 128$\\
$122 \boxtimes 4 = 122 \cdot 4 \bmod 128 = 488 \bmod 128 = 104$}
\end{description}

\paragraph{Addition/Subtraktion modulo $n$}
\begin{description}
\item[Abk\"urzungen/Symbole:] {$+\bmod n$, $-\bmod n$, $+_{n}$, $-_{n}$, $\boxplus$, $\boxminus$}
\item[Definition:] {Die Addition mod n ist definiert als:
\begin{equation*}
\begin{array}{ll}
\boxplus:&\left\{\begin{array}{ll}\mathbb{Z}_{n}\times\mathbb{Z}_{n}&\rightarrow \mathbb{Z}_{n}\\
(x,y) &\mapsto x + y\bmod n\end{array}\right.\\
\end{array}
\end{equation*}
entsprechend die Subtraktion als:
\begin{equation*}
\begin{array}{ll}
\boxminus:&\left\{\begin{array}{ll}\mathbb{Z}_{n}\times\mathbb{Z}_{n}&\rightarrow \mathbb{Z}_{n}\\
(x,y) &\mapsto x - y\bmod n\end{array}\right.\\
\end{array}
\end{equation*}}
\item[Beschreibung:] {Die Addition bzw. Subtraktion modulo $n$}
%\item[Herkunft:]{}
\item[Verwendung:] {Adddition bzw. Subtraktion modulo $n$ werden als alternative zu $xor$ verwendet, beispielsweise um Schl\"ussel und Klartexte zu verkn\"upfen.}
\item[Beispiele:] {
Sei $n=128$\\
$120\boxplus 10 = 120 + 10 \bmod 128 = 130 \bmod 128 = 2$\\
$10\boxminus 15 = 10 - 15 \bmod 128 = -5 \bmod 128 = 123$}
\end{description}
